Acorn User: China

home *** CD-ROM | disk | FTP | other *** search

/ Acorn User: China / Acorn User China CD-ROM (UK) (Disc A) / Acorn User China CD-ROM (UK) (Disc A).bin / DEMON / GNU / FLEX252_.ARC / c_skel < prev next >

Wrap

Text File | 1995-04-24 | 40.0 KB | 1,517 lines

/* File created from flex.skl via mkskel.sh */ #include "flexdef.h" const char *skel[] = { "/* A lexical scanner generated by flex */", "", "/* Scanner skeleton version:", " * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.85 95/04/24 10:48:47 vern Exp $", " */", "", "#define FLEX_SCANNER", "#define YY_FLEX_MAJOR_VERSION 2", "#define YY_FLEX_MINOR_VERSION 5", "", "%-", "#include <stdio.h>", "%*", "", "", "/* cfront 1.2 defines \"c_plusplus\" instead of \"__cplusplus\" */", "#ifdef c_plusplus", "#ifndef __cplusplus", "#define __cplusplus", "#endif", "#endif", "", "", "#ifdef __cplusplus", "", "#include <stdlib.h>", "%+", "class istream;", "%*", "#include <unistd.h>", "", "/* Use prototypes in function declarations. */", "#define YY_USE_PROTOS", "", "/* The \"const\" storage-class-modifier is valid. */", "#define YY_USE_CONST", "", "#else /* ! __cplusplus */", "", "#if __STDC__", "", "#define YY_USE_PROTOS", "#define YY_USE_CONST", "", "#endif /* __STDC__ */", "#endif /* ! __cplusplus */", "", "#ifdef __TURBOC__", " #pragma warn -rch", " #pragma warn -use", "#include <io.h>", "#include <stdlib.h>", "#define YY_USE_CONST", "#define YY_USE_PROTOS", "#endif", "", "#ifdef YY_USE_CONST", "#define yyconst const", "#else", "#define yyconst", "#endif", "", "", "#ifdef YY_USE_PROTOS", "#define YY_PROTO(proto) proto", "#else", "#define YY_PROTO(proto) ()", "#endif", "", "/* Returned upon end-of-file. */", "#define YY_NULL 0", "", "/* Promotes a possibly negative, possibly signed char to an unsigned", " * integer for use as an array index. If the signed char is negative,", " * we want to instead treat it as an 8-bit unsigned char, hence the", " * double cast.", " */", "#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)", "", "/* Enter a start condition. This macro really ought to take a parameter,", " * but we do it the disgusting crufty way forced on us by the ()-less", " * definition of BEGIN.", " */", "#define BEGIN yy_start = 1 + 2 *", "", "/* Translate the current start state into a value that can be later handed", " * to BEGIN to return to the state. The YYSTATE alias is for lex", " * compatibility.", " */", "#define YY_START ((yy_start - 1) / 2)", "#define YYSTATE YY_START", "", "/* Action number for EOF rule of a given start state. */", "#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)", "", "/* Special action meaning \"start processing a new file\". */", "#define YY_NEW_FILE yyrestart( yyin )", "", "#define YY_END_OF_BUFFER_CHAR 0", "", "/* Size of default input buffer. */", "#define YY_BUF_SIZE 16384", "", "typedef struct yy_buffer_state *YY_BUFFER_STATE;", "", "extern int yyleng;", "%-", "extern FILE *yyin, *yyout;", "%*", "", "#define EOB_ACT_CONTINUE_SCAN 0", "#define EOB_ACT_END_OF_FILE 1", "#define EOB_ACT_LAST_MATCH 2", "", "/* The funky do-while in the following #define is used to turn the definition", " * int a single C statement (which needs a semi-colon terminator). This", " * avoids problems with code like:", " *", " * if ( condition_holds )", " * yyless( 5 );", " * else", " * do_something_else();", " *", " * Prior to using the do-while the compiler would get upset at the", " * \"else\" because it interpreted the \"if\" statement as being all", " * done when it reached the ';' after the yyless() call.", " */", "", "/* Return all but the first 'n' matched characters back to the input stream. */", "", "#define yyless(n) \\", " do \\", " { \\", " /* Undo effects of setting up yytext. */ \\", " *yy_cp = yy_hold_char; \\", " yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \\", " YY_DO_BEFORE_ACTION; /* set up yytext again */ \\", " } \\", " while ( 0 )", "", "#define unput(c) yyunput( c, yytext_ptr )", "", "/* The following is because we cannot portably get our hands on size_t", " * (without autoconf's help, which isn't available because we want", " * flex-generated scanners to compile on their own).", " */", "typedef unsigned int yy_size_t;", "", "", "struct yy_buffer_state", " {", "%-", " FILE *yy_input_file;", "%+", " istream* yy_input_file;", "%*", "", " char *yy_ch_buf; /* input buffer */", " char *yy_buf_pos; /* current position in input buffer */", "", " /* Size of input buffer in bytes, not including room for EOB", " * characters.", " */", " yy_size_t yy_buf_size;", "", " /* Number of characters read into yy_ch_buf, not including EOB", " * characters.", " */", " int yy_n_chars;", "", " /* Whether we \"own\" the buffer - i.e., we know we created it,", " * and can realloc() it to grow it, and should free() it to", " * delete it.", " */", " int yy_is_our_buffer;", "", " /* Whether this is an \"interactive\" input source; if so, and", " * if we're using stdio for input, then we want to use getc()", " * instead of fread(), to make sure we stop fetching input after", " * each newline.", " */", " int yy_is_interactive;", "", " /* Whether we're considered to be at the beginning of a line.", " * If so, '^' rules will be active on the next match, otherwise", " * not.", " */", " int yy_at_bol;", "", " /* Whether to try to fill the input buffer when we reach the", " * end of it.", " */", " int yy_fill_buffer;", "", " int yy_buffer_status;", "#define YY_BUFFER_NEW 0", "#define YY_BUFFER_NORMAL 1", " /* When an EOF's been seen but there's still some text to process", " * then we mark the buffer as YY_EOF_PENDING, to indicate that we", " * shouldn't try reading from the input source any more. We might", " * still have a bunch of tokens to match, though, because of", " * possible backing-up.", " *", " * When we actually see the EOF, we change the status to \"new\"", " * (via yyrestart()), so that the user can continue scanning by", " * just pointing yyin at a new input file.", " */", "#define YY_BUFFER_EOF_PENDING 2", " };", "", "%- Standard (non-C++) definition", "static YY_BUFFER_STATE yy_current_buffer = 0;", "%*", "", "/* We provide macros for accessing buffer states in case in the", " * future we want to put the buffer states in a more general", " * \"scanner state\".", " */", "#define YY_CURRENT_BUFFER yy_current_buffer", "", "", "%- Standard (non-C++) definition", "/* yy_hold_char holds the character lost when yytext is formed. */", "static char yy_hold_char;", "", "static int yy_n_chars; /* number of characters read into yy_ch_buf */", "", "", "int yyleng;", "", "/* Points to current character in buffer. */", "static char *yy_c_buf_p = (char *) 0;", "static int yy_init = 1; /* whether we need to initialize */", "static int yy_start = 0; /* start state number */", "", "/* Flag which is used to allow yywrap()'s to do buffer switches", " * instead of setting up a fresh yyin. A bit of a hack ...", " */", "static int yy_did_buffer_switch_on_eof;", "", "void yyrestart YY_PROTO(( FILE *input_file ));", "", "void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));", "void yy_load_buffer_state YY_PROTO(( void ));", "YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));", "void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));", "void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));", "void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));", "#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )", "", "YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));", "YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *str ));", "YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));", "%*", "", "static void *yy_flex_alloc YY_PROTO(( yy_size_t ));", "static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));", "static void yy_flex_free YY_PROTO(( void * ));", "", "#define yy_new_buffer yy_create_buffer", "", "#define yy_set_interactive(is_interactive) \\", " { \\", " if ( ! yy_current_buffer ) \\", " yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \\", " yy_current_buffer->yy_is_interactive = is_interactive; \\", " }", "", "#define yy_set_bol(at_bol) \\", " { \\", " if ( ! yy_current_buffer ) \\", " yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \\", " yy_current_buffer->yy_at_bol = at_bol; \\", " }", "", "#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)", "", "%% yytext/yyin/yyout/yy_state_type/yylineno etc. def's & init go here", "", "%- Standard (non-C++) definition", "static yy_state_type yy_get_previous_state YY_PROTO(( void ));", "static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));", "static int yy_get_next_buffer YY_PROTO(( void ));", "static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));", "%*", "", "/* Done after the current pattern has been matched and before the", " * corresponding action - sets up yytext.", " */", "#define YY_DO_BEFORE_ACTION \\", " yytext_ptr = yy_bp; \\", "%% code to fiddle yytext and yyleng for yymore() goes here", " yy_hold_char = *yy_cp; \\", " *yy_cp = '\\0'; \\", "%% code to copy yytext_ptr to yytext[] goes here, if %array", " yy_c_buf_p = yy_cp;", "", "%% data tables for the DFA and the user's section 1 definitions go here", "", "/* Macros after this point can all be overridden by user definitions in", " * section 1.", " */", "", "#ifndef YY_SKIP_YYWRAP", "#ifdef __cplusplus", "extern \"C\" int yywrap YY_PROTO(( void ));", "#else", "extern int yywrap YY_PROTO(( void ));", "#endif", "#endif", "", "%-", "#ifndef YY_NO_UNPUT", "static void yyunput YY_PROTO(( int c, char *buf_ptr ));", "#endif", "%*", "", "#ifndef yytext_ptr", "static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));", "#endif", "", "#ifndef YY_NO_INPUT", "%- Standard (non-C++) definition", "#ifdef __cplusplus", "static int yyinput YY_PROTO(( void ));", "#else", "static int input YY_PROTO(( void ));", "#endif", "%*", "#endif", "", "#if YY_STACK_USED", "static int yy_start_stack_ptr = 0;", "static int yy_start_stack_depth = 0;", "static int *yy_start_stack = 0;", "#ifndef YY_NO_PUSH_STATE", "static void yy_push_state YY_PROTO(( int new_state ));", "#endif", "#ifndef YY_NO_POP_STATE", "static void yy_pop_state YY_PROTO(( void ));", "#endif", "#ifndef YY_NO_TOP_STATE", "static int yy_top_state YY_PROTO(( void ));", "#endif", "", "#else", "#define YY_NO_PUSH_STATE 1", "#define YY_NO_POP_STATE 1", "#define YY_NO_TOP_STATE 1", "#endif", "", "#ifdef YY_MALLOC_DECL", "YY_MALLOC_DECL", "#else", "#if __STDC__", "#ifndef __cplusplus", "#include <stdlib.h>", "#endif", "#else", "/* Just try to get by without declaring the routines. This will fail", " * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)", " * or sizeof(void*) != sizeof(int).", " */", "#endif", "#endif", "", "/* Amount of stuff to slurp up with each read. */", "#ifndef YY_READ_BUF_SIZE", "#define YY_READ_BUF_SIZE 8192", "#endif", "", "/* Copy whatever the last rule matched to the standard output. */", "", "#ifndef ECHO", "%- Standard (non-C++) definition", "/* This used to be an fputs(), but since the string might contain NUL's,", " * we now use fwrite().", " */", "#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )", "%+ C++ definition", "#define ECHO LexerOutput( yytext, yyleng )", "%*", "#endif", "", "/* Gets input and stuffs it into \"buf\". number of characters read, or YY_NULL,", " * is returned in \"result\".", " */", "#ifndef YY_INPUT", "#define YY_INPUT(buf,result,max_size) \\", "%% fread()/read() definition of YY_INPUT goes here unless we're doing C++", "%+ C++ definition", " if ( (result = LexerInput( (char *) buf, max_size )) < 0 ) \\", " YY_FATAL_ERROR( \"input in flex scanner failed\" );", "%*", "#endif", "", "/* No semi-colon after return; correct usage is to write \"yyterminate();\" -", " * we don't want an extra ';' after the \"return\" because that will cause", " * some compilers to complain about unreachable statements.", " */", "#ifndef yyterminate", "#define yyterminate() return YY_NULL", "#endif", "", "/* Number of entries by which start-condition stack grows. */", "#ifndef YY_START_STACK_INCR", "#define YY_START_STACK_INCR 25", "#endif", "", "/* Report a fatal error. */", "#ifndef YY_FATAL_ERROR", "%-", "#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )", "%+", "#define YY_FATAL_ERROR(msg) LexerError( msg )", "%*", "#endif", "", "/* Default declaration of generated scanner - a define so the user can", " * easily add parameters.", " */", "#ifndef YY_DECL", "%- Standard (non-C++) definition", "#define YY_DECL int yylex YY_PROTO(( void ))", "%+ C++ definition", "#define YY_DECL int yyFlexLexer::yylex()", "%*", "#endif", "", "/* Code executed at the beginning of each rule, after yytext and yyleng", " * have been set up.", " */", "#ifndef YY_USER_ACTION", "#define YY_USER_ACTION", "#endif", "", "/* Code executed at the end of each rule. */", "#ifndef YY_BREAK", "#define YY_BREAK break;", "#endif", "", "%% YY_RULE_SETUP definition goes here", "", "YY_DECL", " {", " register yy_state_type yy_current_state;", " register char *yy_cp, *yy_bp;", " register int yy_act;", "", "%% user's declarations go here", "", " if ( yy_init )", " {", " yy_init = 0;", "", "#ifdef YY_USER_INIT", " YY_USER_INIT;", "#endif", "", " if ( ! yy_start )", " yy_start = 1; /* first start state */", "", " if ( ! yyin )", "%-", " yyin = stdin;", "%+", " yyin = &cin;", "%*", "", " if ( ! yyout )", "%-", " yyout = stdout;", "%+", " yyout = &cout;", "%*", "", " if ( ! yy_current_buffer )", " yy_current_buffer =", " yy_create_buffer( yyin, YY_BUF_SIZE );", "", " yy_load_buffer_state();", " }", "", " while ( 1 ) /* loops until end-of-file is reached */", " {", "%% yymore()-related code goes here", " yy_cp = yy_c_buf_p;", "", " /* Support of yytext. */", " *yy_cp = yy_hold_char;", "", " /* yy_bp points to the position in yy_ch_buf of the start of", " * the current run.", " */", " yy_bp = yy_cp;", "", "%% code to set up and find next match goes here", "", "yy_find_action:", "%% code to find the action number goes here", "", " YY_DO_BEFORE_ACTION;", "", "%% code for yylineno update goes here", "", "do_action: /* This label is used only to access EOF actions. */", "", "%% debug code goes here", "", " switch ( yy_act )", " { /* beginning of action switch */", "%% actions go here", "", " case YY_END_OF_BUFFER:", " {", " /* Amount of text matched not including the EOB char. */", " int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;", "", " /* Undo the effects of YY_DO_BEFORE_ACTION. */", " *yy_cp = yy_hold_char;", "", " if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )", " {", " /* We're scanning a new file or input source. It's", " * possible that this happened because the user", " * just pointed yyin at a new source and called", " * yylex(). If so, then we have to assure", " * consistency between yy_current_buffer and our", " * globals. Here is the right place to do so, because", " * this is the first action (other than possibly a", " * back-up) that will match for the new input source.", " */", " yy_n_chars = yy_current_buffer->yy_n_chars;", " yy_current_buffer->yy_input_file = yyin;", " yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;", " }", "", " /* Note that here we test for yy_c_buf_p \"<=\" to the position", " * of the first EOB in the buffer, since yy_c_buf_p will", " * already have been incremented past the NUL character", " * (since all states make transitions on EOB to the", " * end-of-buffer state). Contrast this with the test", " * in input().", " */", " if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )", " { /* This was really a NUL. */", " yy_state_type yy_next_state;", "", " yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;", "", " yy_current_state = yy_get_previous_state();", "", " /* Okay, we're now positioned to make the NUL", " * transition. We couldn't have", " * yy_get_previous_state() go ahead and do it", " * for us because it doesn't know how to deal", " * with the possibility of jamming (and we don't", " * want to build jamming into it because then it", " * will run more slowly).", " */", "", " yy_next_state = yy_try_NUL_trans( yy_current_state );", "", " yy_bp = yytext_ptr + YY_MORE_ADJ;", "", " if ( yy_next_state )", " {", " /* Consume the NUL. */", " yy_cp = ++yy_c_buf_p;", " yy_current_state = yy_next_state;", " goto yy_match;", " }", "", " else", " {", "%% code to do back-up for compressed tables and set up yy_cp goes here", " goto yy_find_action;", " }", " }", "", " else switch ( yy_get_next_buffer() )", " {", " case EOB_ACT_END_OF_FILE:", " {", " yy_did_buffer_switch_on_eof = 0;", "", " if ( yywrap() )", " {", " /* Note: because we've taken care in", " * yy_get_next_buffer() to have set up", " * yytext, we can now set up", " * yy_c_buf_p so that if some total", " * hoser (like flex itself) wants to", " * call the scanner after we return the", " * YY_NULL, it'll still work - another", " * YY_NULL will get returned.", " */", " yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;", "", " yy_act = YY_STATE_EOF(YY_START);", " goto do_action;", " }", "", " else", " {", " if ( ! yy_did_buffer_switch_on_eof )", " YY_NEW_FILE;", " }", " break;", " }", "", " case EOB_ACT_CONTINUE_SCAN:", " yy_c_buf_p =", " yytext_ptr + yy_amount_of_matched_text;", "", " yy_current_state = yy_get_previous_state();", "", " yy_cp = yy_c_buf_p;", " yy_bp = yytext_ptr + YY_MORE_ADJ;", " goto yy_match;", "", " case EOB_ACT_LAST_MATCH:", " yy_c_buf_p =", " &yy_current_buffer->yy_ch_buf[yy_n_chars];", "", " yy_current_state = yy_get_previous_state();", "", " yy_cp = yy_c_buf_p;", " yy_bp = yytext_ptr + YY_MORE_ADJ;", " goto yy_find_action;", " }", " break;", " }", "", " default:", " YY_FATAL_ERROR(", " \"fatal flex scanner internal error--no action found\" );", " } /* end of action switch */", " } /* end of scanning one token */", " } /* end of yylex */", "", "%+", "yyFlexLexer::yyFlexLexer( istream* arg_yyin, ostream* arg_yyout )", " {", " yyin = arg_yyin;", " yyout = arg_yyout;", " yy_c_buf_p = 0;", " yy_init = 1;", " yy_start = 0;", " yy_flex_debug = 0;", " yylineno = 1; // this will only get updated if %option yylineno", "", " yy_did_buffer_switch_on_eof = 0;", "", " yy_looking_for_trail_begin = 0;", " yy_more_flag = 0;", " yy_more_len = 0;", "", " yy_start_stack_ptr = yy_start_stack_depth = 0;", " yy_start_stack = 0;", "", " yy_current_buffer = 0;", "", "#ifdef YY_USES_REJECT", " yy_state_buf = new yy_state_type[YY_BUF_SIZE + 2];", "#else", " yy_state_buf = 0;", "#endif", " }", "", "yyFlexLexer::~yyFlexLexer()", " {", " delete yy_state_buf;", " yy_delete_buffer( yy_current_buffer );", " }", "", "void yyFlexLexer::switch_streams( istream* new_in, ostream* new_out )", " {", " if ( new_in )", " {", " yy_delete_buffer( yy_current_buffer );", " yy_switch_to_buffer( yy_create_buffer( new_in, YY_BUF_SIZE ) );", " }", "", " if ( new_out )", " yyout = new_out;", " }", "", "#ifdef YY_INTERACTIVE", "int yyFlexLexer::LexerInput( char* buf, int /* max_size */ )", "#else", "int yyFlexLexer::LexerInput( char* buf, int max_size )", "#endif", " {", " if ( yyin->eof() || yyin->fail() )", " return 0;", "", "#ifdef YY_INTERACTIVE", " yyin->get( buf[0] );", "", " if ( yyin->eof() )", " return 0;", "", " if ( yyin->bad() )", " return -1;", "", " return 1;", "", "#else", " (void) yyin->read( buf, max_size );", "", " if ( yyin->bad() )", " return -1;", " else", " return yyin->gcount();", "#endif", " }", "", "void yyFlexLexer::LexerOutput( const char* buf, int size )", " {", " (void) yyout->write( buf, size );", " }", "%*", "", "/* yy_get_next_buffer - try to read in a new buffer", " *", " * Returns a code representing an action:", " * EOB_ACT_LAST_MATCH -", " * EOB_ACT_CONTINUE_SCAN - continue scanning from current position", " * EOB_ACT_END_OF_FILE - end of file", " */", "", "%-", "static int yy_get_next_buffer()", "%+", "int yyFlexLexer::yy_get_next_buffer()", "%*", " {", " register char *dest = yy_current_buffer->yy_ch_buf;", " register char *source = yytext_ptr;", " register int number_to_move, i;", " int ret_val;", "", " if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )", " YY_FATAL_ERROR(", " \"fatal flex scanner internal error--end of buffer missed\" );", "", " if ( yy_current_buffer->yy_fill_buffer == 0 )", " { /* Don't try to fill the buffer, so this is an EOF. */", " if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )", " {", " /* We matched a singled characater, the EOB, so", " * treat this as a final EOF.", " */", " return EOB_ACT_END_OF_FILE;", " }", "", " else", " {", " /* We matched some text prior to the EOB, first", " * process it.", " */", " return EOB_ACT_LAST_MATCH;", " }", " }", "", " /* Try to read more data. */", "", " /* First move last chars to start of buffer. */", " number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;", "", " for ( i = 0; i < number_to_move; ++i )", " *(dest++) = *(source++);", "", " if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )", " /* don't do the read, it's not guaranteed to return an EOF,", " * just force an EOF", " */", " yy_n_chars = 0;", "", " else", " {", " int num_to_read =", " yy_current_buffer->yy_buf_size - number_to_move - 1;", "", " while ( num_to_read <= 0 )", " { /* Not enough room in the buffer - grow it. */", "#ifdef YY_USES_REJECT", " YY_FATAL_ERROR(", "\"input buffer overflow, can't enlarge buffer because scanner uses REJECT\" );", "#else", "", " /* just a shorter name for the current buffer */", " YY_BUFFER_STATE b = yy_current_buffer;", "", " int yy_c_buf_p_offset =", " (int) (yy_c_buf_p - b->yy_ch_buf);", "", " if ( b->yy_is_our_buffer )", " {", " int new_size = b->yy_buf_size * 2;", "", " if ( new_size <= 0 )", " b->yy_buf_size += b->yy_buf_size / 8;", " else", " b->yy_buf_size *= 2;", "", " b->yy_ch_buf = (char *)", " /* Include room in for 2 EOB chars. */", " yy_flex_realloc( (void *) b->yy_ch_buf,", " b->yy_buf_size + 2 );", " }", " else", " /* Can't grow it, we don't own it. */", " b->yy_ch_buf = 0;", "", " if ( ! b->yy_ch_buf )", " YY_FATAL_ERROR(", " \"fatal error - scanner input buffer overflow\" );", "", " yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];", "", " num_to_read = yy_current_buffer->yy_buf_size -", " number_to_move - 1;", "#endif", " }", "", " if ( num_to_read > YY_READ_BUF_SIZE )", " num_to_read = YY_READ_BUF_SIZE;", "", " /* Read in more data. */", " YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),", " yy_n_chars, num_to_read );", " }", "", " if ( yy_n_chars == 0 )", " {", " if ( number_to_move == YY_MORE_ADJ )", " {", " ret_val = EOB_ACT_END_OF_FILE;", " yyrestart( yyin );", " }", "", " else", " {", " ret_val = EOB_ACT_LAST_MATCH;", " yy_current_buffer->yy_buffer_status =", " YY_BUFFER_EOF_PENDING;", " }", " }", "", " else", " ret_val = EOB_ACT_CONTINUE_SCAN;", "", " yy_n_chars += number_to_move;", " yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;", " yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;", "", " yytext_ptr = &yy_current_buffer->yy_ch_buf[0];", "", " return ret_val;", " }", "", "", "/* yy_get_previous_state - get the state just before the EOB char was reached */", "", "%-", "static yy_state_type yy_get_previous_state()", "%+", "yy_state_type yyFlexLexer::yy_get_previous_state()", "%*", " {", " register yy_state_type yy_current_state;", " register char *yy_cp;", "", "%% code to get the start state into yy_current_state goes here", "", " for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )", " {", "%% code to find the next state goes here", " }", "", " return yy_current_state;", " }", "", "", "/* yy_try_NUL_trans - try to make a transition on the NUL character", " *", " * synopsis", " * next_state = yy_try_NUL_trans( current_state );", " */", "", "%-", "#ifdef YY_USE_PROTOS", "static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )", "#else", "static yy_state_type yy_try_NUL_trans( yy_current_state )", "yy_state_type yy_current_state;", "#endif", "%+", "yy_state_type yyFlexLexer::yy_try_NUL_trans( yy_state_type yy_current_state )", "%*", " {", " register int yy_is_jam;", "%% code to find the next state, and perhaps do backing up, goes here", "", " return yy_is_jam ? 0 : yy_current_state;", " }", "", "", "%-", "#ifndef YY_NO_UNPUT", "#ifdef YY_USE_PROTOS", "static void yyunput( int c, register char *yy_bp )", "#else", "static void yyunput( c, yy_bp )", "int c;", "register char *yy_bp;", "#endif", "%+", "void yyFlexLexer::yyunput( int c, register char* yy_bp )", "%*", " {", " register char *yy_cp = yy_c_buf_p;", "", " /* undo effects of setting up yytext */", " *yy_cp = yy_hold_char;", "", " if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )", " { /* need to shift things up to make room */", " /* +2 for EOB chars. */", " register int number_to_move = yy_n_chars + 2;", " register char *dest = &yy_current_buffer->yy_ch_buf[", " yy_current_buffer->yy_buf_size + 2];", " register char *source =", " &yy_current_buffer->yy_ch_buf[number_to_move];", "", " while ( source > yy_current_buffer->yy_ch_buf )", " *--dest = *--source;", "", " yy_cp += (int) (dest - source);", " yy_bp += (int) (dest - source);", " yy_n_chars = yy_current_buffer->yy_buf_size;", "", " if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )", " YY_FATAL_ERROR( \"flex scanner push-back overflow\" );", " }", "", " *--yy_cp = (char) c;", "", "%% update yylineno here", "", " yytext_ptr = yy_bp;", " yy_hold_char = *yy_cp;", " yy_c_buf_p = yy_cp;", " }", "%-", "#endif /* ifndef YY_NO_UNPUT */", "%*", "", "", "%-", "#ifdef __cplusplus", "static int yyinput()", "#else", "static int input()", "#endif", "%+", "int yyFlexLexer::yyinput()", "%*", " {", " int c;", "", " *yy_c_buf_p = yy_hold_char;", "", " if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )", " {", " /* yy_c_buf_p now points to the character we want to return.", " * If this occurs *before* the EOB characters, then it's a", " * valid NUL; if not, then we've hit the end of the buffer.", " */", " if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )", " /* This was really a NUL. */", " *yy_c_buf_p = '\\0';", "", " else", " { /* need more input */", " yytext_ptr = yy_c_buf_p;", " ++yy_c_buf_p;", "", " switch ( yy_get_next_buffer() )", " {", " case EOB_ACT_END_OF_FILE:", " {", " if ( yywrap() )", " {", " yy_c_buf_p =", " yytext_ptr + YY_MORE_ADJ;", " return EOF;", " }", "", " if ( ! yy_did_buffer_switch_on_eof )", " YY_NEW_FILE;", "#ifdef __cplusplus", " return yyinput();", "#else", " return input();", "#endif", " }", "", " case EOB_ACT_CONTINUE_SCAN:", " yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;", " break;", "", " case EOB_ACT_LAST_MATCH:", "#ifdef __cplusplus", " YY_FATAL_ERROR(", " \"unexpected last match in yyinput()\" );", "#else", " YY_FATAL_ERROR(", " \"unexpected last match in input()\" );", "#endif", " }", " }", " }", "", " c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */", " *yy_c_buf_p = '\\0'; /* preserve yytext */", " yy_hold_char = *++yy_c_buf_p;", "", "%% update BOL and yylineno", "", " return c;", " }", "", "", "%-", "#ifdef YY_USE_PROTOS", "void yyrestart( FILE *input_file )", "#else", "void yyrestart( input_file )", "FILE *input_file;", "#endif", "%+", "void yyFlexLexer::yyrestart( istream* input_file )", "%*", " {", " if ( ! yy_current_buffer )", " yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );", "", " yy_init_buffer( yy_current_buffer, input_file );", " yy_load_buffer_state();", " }", "", "", "%-", "#ifdef YY_USE_PROTOS", "void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )", "#else", "void yy_switch_to_buffer( new_buffer )", "YY_BUFFER_STATE new_buffer;", "#endif", "%+", "void yyFlexLexer::yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )", "%*", " {", " if ( yy_current_buffer == new_buffer )", " return;", "", " if ( yy_current_buffer )", " {", " /* Flush out information for old buffer. */", " *yy_c_buf_p = yy_hold_char;", " yy_current_buffer->yy_buf_pos = yy_c_buf_p;", " yy_current_buffer->yy_n_chars = yy_n_chars;", " }", "", " yy_current_buffer = new_buffer;", " yy_load_buffer_state();", "", " /* We don't actually know whether we did this switch during", " * EOF (yywrap()) processing, but the only time this flag", " * is looked at is after yywrap() is called, so it's safe", " * to go ahead and always set it.", " */", " yy_did_buffer_switch_on_eof = 1;", " }", "", "", "%-", "#ifdef YY_USE_PROTOS", "void yy_load_buffer_state( void )", "#else", "void yy_load_buffer_state()", "#endif", "%+", "void yyFlexLexer::yy_load_buffer_state()", "%*", " {", " yy_n_chars = yy_current_buffer->yy_n_chars;", " yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;", " yyin = yy_current_buffer->yy_input_file;", " yy_hold_char = *yy_c_buf_p;", " }", "", "", "%-", "#ifdef YY_USE_PROTOS", "YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )", "#else", "YY_BUFFER_STATE yy_create_buffer( file, size )", "FILE *file;", "int size;", "#endif", "%+", "YY_BUFFER_STATE yyFlexLexer::yy_create_buffer( istream* file, int size )", "%*", " {", " YY_BUFFER_STATE b;", "", " b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );", " if ( ! b )", " YY_FATAL_ERROR( \"out of dynamic memory in yy_create_buffer()\" );", "", " b->yy_buf_size = size;", "", " /* yy_ch_buf has to be 2 characters longer than the size given because", " * we need to put in 2 end-of-buffer characters.", " */", " b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );", " if ( ! b->yy_ch_buf )", " YY_FATAL_ERROR( \"out of dynamic memory in yy_create_buffer()\" );", "", " b->yy_is_our_buffer = 1;", "", " yy_init_buffer( b, file );", "", " return b;", " }", "", "", "%-", "#ifdef YY_USE_PROTOS", "void yy_delete_buffer( YY_BUFFER_STATE b )", "#else", "void yy_delete_buffer( b )", "YY_BUFFER_STATE b;", "#endif", "%+", "void yyFlexLexer::yy_delete_buffer( YY_BUFFER_STATE b )", "%*", " {", " if ( ! b )", " return;", "", " if ( b == yy_current_buffer )", " yy_current_buffer = (YY_BUFFER_STATE) 0;", "", " if ( b->yy_is_our_buffer )", " yy_flex_free( (void *) b->yy_ch_buf );", "", " yy_flex_free( (void *) b );", " }", "", "", "%-", "#ifndef YY_ALWAYS_INTERACTIVE", "#ifndef YY_NEVER_INTERACTIVE", "extern int isatty YY_PROTO(( int ));", "#endif", "#endif", "", "#ifdef YY_USE_PROTOS", "void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )", "#else", "void yy_init_buffer( b, file )", "YY_BUFFER_STATE b;", "FILE *file;", "#endif", "", "%+", "extern \"C\" int isatty YY_PROTO(( int ));", "void yyFlexLexer::yy_init_buffer( YY_BUFFER_STATE b, istream* file )", "%*", "", " {", " yy_flush_buffer( b );", "", " b->yy_input_file = file;", " b->yy_fill_buffer = 1;", "", "%-", "#if YY_ALWAYS_INTERACTIVE", " b->yy_is_interactive = 1;", "#else", "#if YY_NEVER_INTERACTIVE", " b->yy_is_interactive = 0;", "#else", " b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;", "#endif", "#endif", "%+", " b->yy_is_interactive = 0;", "%*", " }", "", "", "%-", "#ifdef YY_USE_PROTOS", "void yy_flush_buffer( YY_BUFFER_STATE b )", "#else", "void yy_flush_buffer( b )", "YY_BUFFER_STATE b;", "#endif", "", "%+", "void yyFlexLexer::yy_flush_buffer( YY_BUFFER_STATE b )", "%*", " {", " b->yy_n_chars = 0;", "", " /* We always need two end-of-buffer characters. The first causes", " * a transition to the end-of-buffer state. The second causes", " * a jam in that state.", " */", " b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;", " b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;", "", " b->yy_buf_pos = &b->yy_ch_buf[0];", "", " b->yy_at_bol = 1;", " b->yy_buffer_status = YY_BUFFER_NEW;", "", " if ( b == yy_current_buffer )", " yy_load_buffer_state();", " }", "%*", "", "", "#ifndef YY_NO_SCAN_BUFFER", "%-", "#ifdef YY_USE_PROTOS", "YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )", "#else", "YY_BUFFER_STATE yy_scan_buffer( base, size )", "char *base;", "yy_size_t size;", "#endif", " {", " YY_BUFFER_STATE b;", "", " if ( size < 2 ||", " base[size-2] != YY_END_OF_BUFFER_CHAR ||", " base[size-1] != YY_END_OF_BUFFER_CHAR )", " /* They forgot to leave room for the EOB's. */", " return 0;", "", " b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );", " if ( ! b )", " YY_FATAL_ERROR( \"out of dynamic memory in yy_scan_buffer()\" );", "", " b->yy_buf_size = size - 2; /* \"- 2\" to take care of EOB's */", " b->yy_buf_pos = b->yy_ch_buf = base;", " b->yy_is_our_buffer = 0;", " b->yy_input_file = 0;", " b->yy_n_chars = b->yy_buf_size;", " b->yy_is_interactive = 0;", " b->yy_at_bol = 1;", " b->yy_fill_buffer = 0;", " b->yy_buffer_status = YY_BUFFER_NEW;", "", " yy_switch_to_buffer( b );", "", " return b;", " }", "%*", "#endif", "", "", "#ifndef YY_NO_SCAN_STRING", "%-", "#ifdef YY_USE_PROTOS", "YY_BUFFER_STATE yy_scan_string( yyconst char *str )", "#else", "YY_BUFFER_STATE yy_scan_string( str )", "yyconst char *str;", "#endif", " {", " int len;", " for ( len = 0; str[len]; ++len )", " ;", "", " return yy_scan_bytes( str, len );", " }", "%*", "#endif", "", "", "#ifndef YY_NO_SCAN_BYTES", "%-", "#ifdef YY_USE_PROTOS", "YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )", "#else", "YY_BUFFER_STATE yy_scan_bytes( bytes, len )", "yyconst char *bytes;", "int len;", "#endif", " {", " YY_BUFFER_STATE b;", " char *buf;", " yy_size_t n;", " int i;", "", " /* Get memory for full buffer, including space for trailing EOB's. */", " n = len + 2;", " buf = (char *) yy_flex_alloc( n );", " if ( ! buf )", " YY_FATAL_ERROR( \"out of dynamic memory in yy_scan_bytes()\" );", "", " for ( i = 0; i < len; ++i )", " buf[i] = bytes[i];", "", " buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;", "", " b = yy_scan_buffer( buf, n );", " if ( ! b )", " YY_FATAL_ERROR( \"bad buffer in yy_scan_bytes()\" );", "", " /* It's okay to grow etc. this buffer, and we should throw it", " * away when we're done.", " */", " b->yy_is_our_buffer = 1;", "", " return b;", " }", "%*", "#endif", "", "", "#ifndef YY_NO_PUSH_STATE", "%-", "#ifdef YY_USE_PROTOS", "static void yy_push_state( int new_state )", "#else", "static void yy_push_state( new_state )", "int new_state;", "#endif", "%+", "void yyFlexLexer::yy_push_state( int new_state )", "%*", " {", " if ( yy_start_stack_ptr >= yy_start_stack_depth )", " {", " yy_size_t new_size;", "", " yy_start_stack_depth += YY_START_STACK_INCR;", " new_size = yy_start_stack_depth * sizeof( int );", "", " if ( ! yy_start_stack )", " yy_start_stack = (int *) yy_flex_alloc( new_size );", "", " else", " yy_start_stack = (int *) yy_flex_realloc(", " (void *) yy_start_stack, new_size );", "", " if ( ! yy_start_stack )", " YY_FATAL_ERROR(", " \"out of memory expanding start-condition stack\" );", " }", "", " yy_start_stack[yy_start_stack_ptr++] = YY_START;", "", " BEGIN(new_state);", " }", "#endif", "", "", "#ifndef YY_NO_POP_STATE", "%-", "static void yy_pop_state()", "%+", "void yyFlexLexer::yy_pop_state()", "%*", " {", " if ( --yy_start_stack_ptr < 0 )", " YY_FATAL_ERROR( \"start-condition stack underflow\" );", "", " BEGIN(yy_start_stack[yy_start_stack_ptr]);", " }", "#endif", "", "", "#ifndef YY_NO_TOP_STATE", "%-", "static int yy_top_state()", "%+", "int yyFlexLexer::yy_top_state()", "%*", " {", " return yy_start_stack[yy_start_stack_ptr - 1];", " }", "#endif", "", "#ifndef YY_EXIT_FAILURE", "#define YY_EXIT_FAILURE 2", "#endif", "", "%-", "#ifdef YY_USE_PROTOS", "static void yy_fatal_error( yyconst char msg[] )", "#else", "static void yy_fatal_error( msg )", "char msg[];", "#endif", " {", " (void) fprintf( stderr, \"%s\\n\", msg );", " exit( YY_EXIT_FAILURE );", " }", "", "%+", "", "void yyFlexLexer::LexerError( yyconst char msg[] )", " {", " cerr << msg << '\\n';", " exit( YY_EXIT_FAILURE );", " }", "%*", "", "", "/* Redefine yyless() so it works in section 3 code. */", "", "#undef yyless", "#define yyless(n) \\", " do \\", " { \\", " /* Undo effects of setting up yytext. */ \\", " yytext[yyleng] = yy_hold_char; \\", " yy_c_buf_p = yytext + n - YY_MORE_ADJ; \\", " yy_hold_char = *yy_c_buf_p; \\", " *yy_c_buf_p = '\\0'; \\", " yyleng = n; \\", " } \\", " while ( 0 )", "", "", "/* Internal utility routines. */", "", "#ifndef yytext_ptr", "#ifdef YY_USE_PROTOS", "static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )", "#else", "static void yy_flex_strncpy( s1, s2, n )", "char *s1;", "yyconst char *s2;", "int n;", "#endif", " {", " register int i;", " for ( i = 0; i < n; ++i )", " s1[i] = s2[i];", " }", "#endif", "", "", "#ifdef YY_USE_PROTOS", "static void *yy_flex_alloc( yy_size_t size )", "#else", "static void *yy_flex_alloc( size )", "yy_size_t size;", "#endif", " {", " return (void *) malloc( size );", " }", "", "#ifdef YY_USE_PROTOS", "static void *yy_flex_realloc( void *ptr, yy_size_t size )", "#else", "static void *yy_flex_realloc( ptr, size )", "void *ptr;", "yy_size_t size;", "#endif", " {", " /* The cast to (char *) in the following accommodates both", " * implementations that use char* generic pointers, and those", " * that use void* generic pointers. It works with the latter", " * because both ANSI C and C++ allow castless assignment from", " * any pointer type to void*, and deal with argument conversions", " * as though doing an assignment.", " */", " return (void *) realloc( (char *) ptr, size );", " }", "", "#ifdef YY_USE_PROTOS", "static void yy_flex_free( void *ptr )", "#else", "static void yy_flex_free( ptr )", "void *ptr;", "#endif", " {", " free( ptr );", " }", "", "#if YY_MAIN", "int main()", " {", " yylex();", " return 0;", " }", "#endif", 0 };